# a)	运算
#     i.	字符串乘法----字符串 按照所乘倍数重复
#     ii.	字符串加法
#     iii.元组加法、乘法
#     iv.	列表加法、乘法
# b)	序列的大小比较  列表 元组 集合 字符串
#     1.	(1, 2, 3) < (1, 2, 4) 
#     2.	[1, 2, 3] < [1, 2, 4]
#     3.	'ABC' < 'C' < 'Pascal' < 'Python'
#     4.	(1, 2, 3, 4) < (1, 2, 4)
#     5.	(1, 2) < (1, 2, -1)
#     6.	(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
#     7.	(1, 2, 3) == (1.0, 2.0, 3.0)

# c)	可变对象与不可变对象
#     # 当改变一个对象的值时，如果能维持其id值不变，我们就说这个对象是可变的
#     # id(x)不随x的内容变化而变化，就说x是可变的

#     # 常见的不可变类型
#     a = 5
#     b = 5.1
#     c = 'hello world'
#     d = False
#     e = tuple()  # (1, 2, 3)
#     f = set()    # {1, 2, 3}

#     # 可变类型
#     g = list()   # [1, 2, 3]
#     h = dict()   # {"Bob":18, "Tom":22}

# d)	具有固定值的对象。不可变对象包括数字、字符串和元组。这样的对象不能被改变。---可哈希 & 不可哈希
# e)	如果必须存储一个不同的值，则必须创建新的对象
# f)	成员运算符 in /not in 作用于各种对象”sss” in dict \ list \ str \ tuple \ set
# g)	enumerate函数的使用
# h)	zip函数的使用
#     a=[1, 2, 3]
#     b=[4, 5, 6]
#     c=[4, 5, 6, 7, 8]
#     d={'aa': 99, 'bb': 100, 'cc': 101}
#     res=zip(a, b)     # 打包为元组的列表
#     >> [(1, 4),
#         (2, 5),
#         (3, 6)]
#     zip(a, c)              # 所得结果的元素个数与最短的列表一致
#     >> [(1, 4),
#         (2, 5),
#         (3, 6)]
#     zip(a, d)            # 相当于使用  for i in d 对d进行迭代 并将 i和 a中的元素依次合并
#     >> [(1, 'aa'),
#         (2, 'bb'),
#         (3, 'cc')]

# i)	默认类型转换
#     1.	1 + 1.0
#     2.	1 / 2
#     3.	True + 1
#     4.	复数
# j)	强制类型转化
#     1.	float(1) float('100')
#     2.	int(1.0)  int('1') int('1.0')# 报错
#     3.	list(dict) 只能得到keys列表
#     4.	list(str) 字符串每个字符拆解放入列表：list("hello") -> ['h', 'e', 'l', 'l', 'o']
#     5.	list(tuple / set)直接转化
#     6.	str(list / dict / set) 使用其他类型生成对应字符串：
#         a)	str(['h', 'e', 'l', 'l', 'o']) -> "['h', 'e', 'l', 'l', 'o']"
#         b)	str({'k': 1}) -> "{'k': 1}"
#         c)	str({1, 2, 3, 4}) -> '{1, 2, 3, 4}'
#         d)	str(100) -> "100"
# 7.	tuple行为和list强制转化类似
# 8.	set必须是可哈希对象才可强制转换
